home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / proc / readproc.h < prev    next >
C/C++ Source or Header  |  2005-10-13  |  11KB  |  252 lines
  1. #ifndef PROCPS_PROC_READPROC_H
  2. #define PROCPS_PROC_READPROC_H
  3.  
  4. // New Interface to Process Table -- PROCTAB Stream (a la Directory streams)
  5. // Copyright 1996 Charles L. Blake.
  6. // Copyright 1998 Michael K. Johnson
  7. // Copyright 1998-2003 Albert Cahalan
  8. // May be distributed under the terms of the
  9. // GNU Library General Public License, a copy of which is provided
  10. // in the file COPYING
  11.  
  12.  
  13. #include "procps.h"
  14. #include "pwcache.h"
  15.  
  16. #define SIGNAL_STRING
  17.  
  18. EXTERN_C_BEGIN
  19.  
  20. // ld    cutime, cstime, priority, nice, timeout, alarm, rss,
  21. // c    state,
  22. // d    ppid, pgrp, session, tty, tpgid,
  23. // s    signal, blocked, sigignore, sigcatch,
  24. // lu    flags, min_flt, cmin_flt, maj_flt, cmaj_flt, utime, stime,
  25. // lu    rss_rlim, start_code, end_code, start_stack, kstk_esp, kstk_eip,
  26. // lu    start_time, vsize, wchan,
  27.  
  28. // This is to help document a transition from pid to tgid/tid caused
  29. // by the introduction of thread support. It is used in cases where
  30. // neither tgid nor tid seemed correct. (in other words, FIXME)
  31. #define XXXID tid
  32.  
  33. // Basic data structure which holds all information we can get about a process.
  34. // (unless otherwise specified, fields are read from /proc/#/stat)
  35. //
  36. // Most of it comes from task_struct in linux/sched.h
  37. //
  38. typedef struct proc_t {
  39. // 1st 16 bytes
  40.     int
  41.         tid,        // (special)       task id, the POSIX thread ID (see also: tgid)
  42.         ppid;        // stat,status     pid of parent process
  43.     unsigned
  44.         pcpu;           // stat (special)  %CPU usage (is not filled in by readproc!!!)
  45.     char
  46.         state,        // stat,status     single-char code for process state (S=sleeping)
  47.         pad_1,        // n/a             padding
  48.         pad_2,        // n/a             padding
  49.         pad_3;        // n/a             padding
  50. // 2nd 16 bytes
  51.     unsigned long long
  52.     utime,        // stat            user-mode CPU time accumulated by process
  53.     stime,        // stat            kernel-mode CPU time accumulated by process
  54. // and so on...
  55.     cutime,        // stat            cumulative utime of process and reaped children
  56.     cstime,        // stat            cumulative stime of process and reaped children
  57.     start_time;    // stat            start time of process -- seconds since 1-1-70
  58. #ifdef SIGNAL_STRING
  59.     char
  60.     // Linux 2.1.7x and up have 64 signals. Allow 64, plus '\0' and padding.
  61.     signal[18],    // status          mask of pending signals
  62.     blocked[18],    // status          mask of blocked signals
  63.     sigignore[18],    // status          mask of ignored signals
  64.     sigcatch[18];    // status          mask of caught  signals
  65. #else
  66.     long long
  67.     // Linux 2.1.7x and up have 64 signals.
  68.     signal,        // status          mask of pending signals
  69.     blocked,    // status          mask of blocked signals
  70.     sigignore,    // status          mask of ignored signals
  71.     sigcatch;    // status          mask of caught  signals
  72. #endif
  73.     unsigned KLONG
  74.     start_code,    // stat            address of beginning of code segment
  75.     end_code,    // stat            address of end of code segment
  76.     start_stack,    // stat            address of the bottom of stack for the process
  77.     kstk_esp,    // stat            kernel stack pointer
  78.     kstk_eip,    // stat            kernel instruction pointer
  79.     wchan;        // stat (special)  address of kernel wait channel proc is sleeping in
  80.     long
  81.     priority,    // stat            kernel scheduling priority
  82.     nice,        // stat            standard unix nice level of process
  83.     rss,        // stat            resident set size from /proc/#/stat (pages)
  84.     alarm,        // stat            ?
  85.     // the next 7 members come from /proc/#/statm
  86.     size,        // statm           total # of pages of memory
  87.     resident,    // statm           number of resident set (non-swapped) pages (4k)
  88.     share,        // statm           number of pages of shared (mmap'd) memory
  89.     trs,        // statm           text resident set size
  90.     lrs,        // statm           shared-lib resident set size
  91.     drs,        // statm           data resident set size
  92.     dt;        // statm           dirty pages
  93.     unsigned long
  94.     vm_size,        // status          same as vsize in kb
  95.     vm_lock,        // status          locked pages in kb
  96.     vm_rss,         // status          same as rss in kb
  97.     vm_data,        // status          data size
  98.     vm_stack,       // status          stack size
  99.     vm_exe,         // status          executable size
  100.     vm_lib,         // status          library size (all pages, not just used ones)
  101.     rtprio,        // stat            real-time priority
  102.     sched,        // stat            scheduling class
  103.     vsize,        // stat            number of pages of virtual memory ...
  104.     rss_rlim,    // stat            resident set size limit?
  105.     flags,        // stat            kernel flags for the process
  106.     min_flt,    // stat            number of minor page faults since process start
  107.     maj_flt,    // stat            number of major page faults since process start
  108.     cmin_flt,    // stat            cumulative min_flt of process and child processes
  109.     cmaj_flt;    // stat            cumulative maj_flt of process and child processes
  110.     char
  111.     **environ,    // (special)       environment string vector (/proc/#/environ)
  112.     **cmdline;    // (special)       command line string vector (/proc/#/cmdline)
  113.     char
  114.     // Be compatible: Digital allows 16 and NT allows 14 ???
  115.         euser[P_G_SZ],    // stat(),status   effective user name
  116.         ruser[P_G_SZ],    // status          real user name
  117.         suser[P_G_SZ],    // status          saved user name
  118.         fuser[P_G_SZ],    // status          filesystem user name
  119.         rgroup[P_G_SZ],    // status          real group name
  120.         egroup[P_G_SZ],    // status          effective group name
  121.         sgroup[P_G_SZ],    // status          saved group name
  122.         fgroup[P_G_SZ],    // status          filesystem group name
  123.         cmd[16];    // stat,status     basename of executable file in call to exec(2)
  124.     struct proc_t
  125.     *ring,        // n/a             thread group ring
  126.     *next;        // n/a             various library uses
  127.     int
  128.     pgrp,        // stat            process group id
  129.     session,    // stat            session id
  130.     nlwp,        // stat,status     number of threads, or 0 if no clue
  131.     tgid,        // (special)       task group ID, the POSIX PID (see also: tid)
  132.     tty,        // stat            full device number of controlling terminal
  133.         euid, egid,     // stat(),status   effective
  134.         ruid, rgid,     // status          real
  135.         suid, sgid,     // status          saved
  136.         fuid, fgid,     // status          fs (used for file access only)
  137.     tpgid,        // stat            terminal process group id
  138.     exit_signal,    // stat            might not be SIGCHLD
  139.     processor;      // stat            current (or most recent?) CPU
  140. } proc_t;
  141.  
  142. // PROCTAB: data structure holding the persistent information readproc needs
  143. // from openproc().  The setup is intentionally similar to the dirent interface
  144. // and other system table interfaces (utmp+wtmp come to mind).
  145.  
  146. #include <sys/types.h>
  147. #include <dirent.h>
  148. #include <unistd.h>
  149.  
  150. #define PROCPATHLEN 64  // must hold /proc/2000222000/task/2000222000/cmdline
  151.  
  152. typedef struct PROCTAB {
  153.     DIR*    procfs;
  154. //    char deBug0[64];
  155.     DIR*    taskdir;  // for threads
  156. //    char deBug1[64];
  157.     pid_t    taskdir_user;  // for threads
  158.     int         did_fake; // used when taskdir is missing
  159.     int(*finder)(struct PROCTAB *restrict const, proc_t *restrict const);
  160.     proc_t*(*reader)(struct PROCTAB *restrict const, proc_t *restrict const);
  161.     int(*taskfinder)(struct PROCTAB *restrict const, const proc_t *restrict const, proc_t *restrict const, char *restrict const);
  162.     proc_t*(*taskreader)(struct PROCTAB *restrict const, const proc_t *restrict const, proc_t *restrict const, char *restrict const);
  163.     pid_t*    pids;    // pids of the procs
  164.     uid_t*    uids;    // uids of procs
  165.     int        nuid;    // cannot really sentinel-terminate unsigned short[]
  166.     int         i;  // generic
  167.     unsigned    flags;
  168.     unsigned    u;  // generic
  169.     void *      vp; // generic
  170.     char        path[PROCPATHLEN];  // must hold /proc/2000222000/task/2000222000/cmdline
  171.     unsigned pathlen;        // length of string in the above (w/o '\0')
  172. } PROCTAB;
  173.  
  174. // initialize a PROCTAB structure holding needed call-to-call persistent data
  175. extern PROCTAB* openproc(int flags, ... /* pid_t*|uid_t*|dev_t*|char* [, int n] */ );
  176.  
  177. typedef struct proc_data_t {
  178.     proc_t **tab;
  179.     proc_t **proc;
  180.     proc_t **task;
  181.     int n;
  182.     int nproc;
  183.     int ntask;
  184. } proc_data_t;
  185.  
  186. extern proc_data_t *readproctab2(int(*want_proc)(proc_t *buf), int(*want_task)(proc_t *buf), PROCTAB *restrict const PT);
  187.  
  188. // Convenient wrapper around openproc and readproc to slurp in the whole process
  189. // table subset satisfying the constraints of flags and the optional PID list.
  190. // Free allocated memory with exit().  Access via tab[N]->member.  The pointer
  191. // list is NULL terminated.
  192.  
  193. extern proc_t** readproctab(int flags, ... /* same as openproc */ );
  194.  
  195. // clean-up open files, etc from the openproc()
  196. extern void closeproc(PROCTAB* PT);
  197.  
  198. // retrieve the next process matching the criteria set by the openproc()
  199. extern proc_t* readproc(PROCTAB *restrict const PT, proc_t *restrict p);
  200. extern proc_t* readtask(PROCTAB *restrict const PT, const proc_t *restrict const p, proc_t *restrict t);
  201.  
  202. // warning: interface may change
  203. extern int read_cmdline(char *restrict const dst, unsigned sz, unsigned pid);
  204.  
  205. extern void look_up_our_self(proc_t *p);
  206.  
  207. // deallocate space allocated by readproc
  208.  
  209. extern void freeproc(proc_t* p);
  210.  
  211. //fill out a proc_t for a single task
  212. extern proc_t * get_proc_stats(pid_t pid, proc_t *p);
  213.  
  214. // openproc/readproctab:
  215. //
  216. // Return PROCTAB* / *proc_t[] or NULL on error ((probably) "/proc" cannot be
  217. // opened.)  By default readproc will consider all processes as valid to parse
  218. // and return, but not actually fill in the cmdline, environ, and /proc/#/statm
  219. // derived memory fields.
  220. //
  221. // `flags' (a bitwise-or of PROC_* below) modifies the default behavior.  The
  222. // "fill" options will cause more of the proc_t to be filled in.  The "filter"
  223. // options all use the second argument as the pointer to a list of objects:
  224. // process status', process id's, user id's.  The third
  225. // argument is the length of the list (currently only used for lists of user
  226. // id's since uid_t supports no convenient termination sentinel.)
  227.  
  228. #define PROC_FILLMEM         0x0001 // read statm
  229. #define PROC_FILLCOM         0x0002 // alloc and fill in `cmdline'
  230. #define PROC_FILLENV         0x0004 // alloc and fill in `environ'
  231. #define PROC_FILLUSR         0x0008 // resolve user id number -> user name
  232. #define PROC_FILLGRP         0x0010 // resolve group id number -> group name
  233. #define PROC_FILLSTATUS      0x0020 // read status -- currently unconditional
  234. #define PROC_FILLSTAT        0x0040 // read stat -- currently unconditional
  235. #define PROC_FILLWCHAN       0x0080 // look up WCHAN name
  236. #define PROC_FILLARG         0x0100 // alloc and fill in `cmdline'
  237.  
  238. #define PROC_LOOSE_TASKS     0x0200 // threat threads as if they were processes
  239.  
  240. // Obsolete, consider only processes with one of the passed:
  241. #define PROC_PID             0x1000  // process id numbers ( 0   terminated)
  242. #define PROC_UID             0x4000  // user id numbers    ( length needed )
  243.  
  244. // it helps to give app code a few spare bits
  245. #define PROC_SPARE_1     0x01000000
  246. #define PROC_SPARE_2     0x02000000
  247. #define PROC_SPARE_3     0x04000000
  248. #define PROC_SPARE_4     0x08000000
  249.  
  250. EXTERN_C_END
  251. #endif
  252.